闲话 22.10.4

闲话

今日休息
所以我看着一堆人在打PCK
“码力是很重要的”
所以我没去打
于是今天的杂题有两道！
写完这句话后开了第三题 发现这是nmd结论题
于是今天的杂题有三道

我是什么废物两个小时实现不出来这个结论
于是今天的杂题还是两道
行吧我题读错了 怪不得我模不出样例
所以今天的杂题还是三道

似乎上次自由时间我写了 4 道题来着
所以我在退步（确信）

晚饭回来更新：
路上在躲跑餐的学生们
然后往旁边一躲
脚下躺着的楼号牌：不好意思，这里满员了
然后踩了上去
然后一滑
膝盖：Full Combo~

70億の秘密と同じだけの

純粋が欲しくなるのは何故？

何が正義か

そんな馬鹿正直なふたりが

わからないよと泣いてる

杂题

蓝智力相当高，尤其擅长数学。据说连人类所无法想象程度的计算都能够在瞬间完成。——《东方求闻史纪》

CF1687D

定义 $f(x)$ 表示严格大于 $x$ 的最小的完全平方数，定义 $g(x)$ 为小于等于 $x$ 的最大的完全平方数。例如，$f(1)=f(2)=g(4)=g(8)=4$。蓝认为，一个正整数是“可爱”的，当且仅当 $x-g(x)<f(x)-x$，例如，$1,5,11$ 是可爱的正整数，而 $3,8,15$ 不是。

蓝给了你一个长度为 $n$ 的正整数数列 $a_i$，你需要帮她找到最小的非负整数 $k$，使得 $\forall\ i$，$a_i+k$ 是可爱的。

$n \le 10^6, a_i \le a_{i+1} \le 2\times 10^6$

打表题。性质题。

观察 打表 经过严密的数学证明可得，可爱的数组成了一段段区间，第 $x$ 段区间可以表为 $[x^2,x(x+1)]$。
当 $a_1$ 位于第 $(a_n - a_1)$ 段区间内时定能得到答案，因此 $k < (a_n - a_1)^2$。

假设 $a_1$ 被放在了第 $v$ 段内。可以发现 $k$ 共有 $v + 1$ 种取值。
当 $k$ 变化时，可能存在原来是可爱数的 $a_i + k$ 变为不可爱的数，反之亦然。
当一个元素的性质发生变化时，就无法通过 $k$ 的继续变化使得其性质发生第二次变化。这是因为 $v$ 段后的所有段长度定 $> v$，其长度大于 $k$ 可能的变化范围。
可以发现，这其实限制了 $k$ 的上下界。

我们初始时令 $a_1 + k$ 位于第 $v$ 段的段首。然后我们向后扫每一段
对于可爱段，我们找到这段内最大的数，这个数标定了 $k$ 取值的上界，因为不能让这个数出可爱段。对于不可爱段，我们找到这段内最小的数，这个数标定了 $k$ 取值的下界，因为需要让这个数增加到离开不可爱段。
于是我们每次扫一下就能得到答案。

这么写的复杂度似乎是 $a_n \log a_n$，具体是不是线性没想。

code

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,a,b) for (register int (i) = (a); (i) <= (b); ++(i))
#define pre(i,a,b) for (register int (i) = (a); (i) >= (b); --(i))
const int N = 1e6 + 10;
int n, a[N], vis[N<<2], nxt[N<<2], pref[N<<2];

signed main() {
    ios::sync_with_stdio(false); cin.tie(0), cout.tie(0);
    cin >> n; rep(i,1,n) cin >> a[i];
    rep(i,2,n) vis[a[i] - a[1]] = 1;
    nxt[4000001] = 1e7, pref[0] = -1;
    rep(i,1,4000000) if (vis[i]) pref[i] = i; else pref[i] = pref[i-1];
    pre(i,4000000,1) if (vis[i]) nxt[i] = i;  else nxt[i] = nxt[i+1];

    rep(i,1,a[n]) {
        if (i * (i+1) < a[1]) continue;
        int l = 0, r = i; if (a[1] > i * i) l = a[1] - i * i;
        
        int nowl = 0, nowr = i;
        for (int j = i ; ; j++) {
            if (pref[nowr] >= nowl) r = min(r, nowr - pref[nowr]);
            nowl += 2 * j + 1;
            if (nxt[nowr+1] < nowl) l = max(l, nowl - nxt[nowr+1]);
            nowr += 2 * j + 2;
            if (l > r or nowl > a[n] - a[1]) break;
        }

        if (l <= r) {
            cout << i * i + l - a[1] << '\n';
            return 0; 
        }
    }
}

---

CF1700F

给定两个 $2 \times n$ 的 $01$ 矩阵 $A$ 和 $B$，定义一次操作为交换 $A$ 中任意两个相邻的位置中的值，输出使得 $A=B$ 的最小操作次数，如果无法使 $A=B$ 则输出 $-1$。

$n \le 2\times 10^5$.

贪心题。

当矩阵是 $1\times n$ 的时候，答案是易求的。
设 $suma_i = \sum_{j=1}^i a[i], sumb_i = \sum_{j=1}^i b[i]$，则最终答案就是

$$\sum_{i=1}^n |suma_i - sumb_i|$$

证明考虑 $a$ 那边多 $k$ 个 1 的情况，直到 $b$ 那边出现 1 为止都得带着这 $k$ 个 1 一直移动，移动一格的花费是 $k = suma_i - sumb_i$。$b$ 多 1 的情况同理，因此加绝对值。

现在矩阵是 $2\times n$ 的了，我们需要得到上下交换的最小花费。
分别记录两个前缀和 $sum_1$ 与 $sum_2$ 分别表示两矩阵第一行的前缀和之差与第二行的前缀和之差。
在当前情况下上下交换当且仅当 $sum_1$ 与 $sum_2$ 异号。当同号时上下交换是不必要的，这时交换肯定不会使答案更优。
异号时应当上下移动至 $sum_1$ 与 $sum_2$ 之一为 0。这样做可以使得全局左右交换的次数最少，肯定不会使答案更劣。
上下移动后应当在答案中加入 $sum_1 + sum_2$，原因同 $1\times n$ 理。

记得开ll。

code

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for (register int (i) = (a); (i) <= (b); ++(i))
#define pre(i,a,b) for (register int (i) = (a); (i) >= (b); --(i))
#define sgn(u) ((u == 0) ? 0 : (u > 0) ? 1 : -1 )
const int N = 2e5 + 10;
int n, a[2][N], b[2][N];
long long cnt, ans;

signed main() {
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    cin >> n;
    rep(i,0,1) rep(j,1,n) cin >> a[i][j], cnt += a[i][j];
    rep(i,0,1) rep(j,1,n) cin >> b[i][j], cnt -= b[i][j];
    if (cnt) { cout << -1 << '\n'; return 0; }
    long long sum0 = 0, sum1 = 0, delt;
    rep(i,1,n) {
        sum0 += a[0][i] - b[0][i], sum1 += a[1][i] - b[1][i];
        if (1ll * sum0 * sum1 < 0) {
            delt = min(abs(sum0), abs(sum1));
            ans += delt;
            sum0 += -sgn(sum0) * delt;
            sum1 += -sgn(sum1) * delt;
        }
        ans += abs(sum0) + abs(sum1);
    } cout << ans << endl;
} 

---

CF1685C

给定一个长度为 $2n$ 的括号序列 $s$，保证其由 $n$ 个左括号 ( 和 $n$ 个右括号 ) 组成。定义一次操作是翻转 $s$ 的一个连续子串。请求出最少几次操作可将 $s$ 转换为合法括号序列。输出最少的操作次数，并构造一种方案。可以证明，这总是能在 $n$ 次操作中完成。

$n \le 2\times 10^5$。

结论题。

注意这里的操作定义是这样的：设我们用 $str$ 数组从下标 1 位置开始存储这个序列，则对 $[l,r]$ 序列的操作等价于 reverse(str+l,str+r+1)。无论如何操作，左括号和右括号的数量不会发生变化，因此 $a_{2n}$ 恒等于 $0$。

括号序列的转化是 ($\to 1$，)$\to -1$，合法括号序列是任意位置非负。
设括号序列 $s$ 的前缀和数组为 $a_i$。若 $\forall i,a_i \ge 0$ 则不需要操作，此后讨论默认 $s$ 不是合法括号序列。

我们断言，使用不超过两次操作就可以得到合法括号序列。

证明

我们只需要找到前缀和数组的最大值 $a_k$，随后翻转 $[1,k]$ 与 $[k+1,2n]$ 即可。

设翻转后的前缀和数组为 $b_i$。
当 $i \le k$ 时，$b_i$ 对应的是原序列 $[i,k]$ 段的和，即 $a_k - a_i$。由于 $a_k$ 最大，因此此情况下 $b_i \ge 0$。
当 $i > k$ 时，$b_i$ 对应的是原序列 $[1,k]$ 段和 $[i,2n]$ 段的和，即 $a_k + a_{2n} - a_{i'}$，其中 $i$ 为 $i'$ 翻转后对应位置。由于 $a_{2n} = 0$ 且 $a_k$ 最大，因此此情况下 $b_i \ge 0$。

因此我们只需要判断是否能仅操作一次。
令 $[L,R]$ 分别为最前和最后一个 $a$ 小于 $0$ 的位置。我们断言，最终翻转的区间 $[l,r]$ 需要满足 $l \le L \le \ R < r$，并且最优选择一定是 $a_{l-1}$ 最大的 $l$ 与 $a_r$ 最大的 r。不保证最优选择在操作后一定得到合法括号序列。

证明

可以知道最终 $[1,l)$ 和 $(r,2n]$ 的前缀和没有变化。这表明最终翻转的区间 $[l,r]$ 需要满足 $l \le L \le \ R < r$。
考察 $[l,r]$ 段新的前缀和 $b_i$，立即列出方程：$b_i = a_{l-1} + a_r - a_{i'}$，其中 $i$ 为 $i'$ 翻转后对应位置。
则当 $a_{l-1} + a_r - a_{i'} \ge 0$ 即 $a_{l-1} + a_r \ge a_{i'}$ 时有操作一次即可得到合法括号序列。
我们只需要贪心地选择最大值即可得到最优选择。

选择后只需要检验一次，若可行则输出 1，若不可行则输出 2。
构造方案平凡，上方已给出。

总时间复杂度 $O(n)$。

code

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for (register int (i) = (a); (i) <= (b); ++(i))
#define pre(i,a,b) for (register int (i) = (a); (i) >= (b); --(i))
const int N = 4e5 + 10;
int T, n, mpos, pref[N];
char ch[N];

bool check(int l, int r) {
    reverse(ch+l, ch+r+1);

    rep(i,l,r) {
        pref[i] = pref[i-1] + (ch[i] == '(' ? 1 : -1);
        if (pref[i] < 0) return false;
    } 
    rep(i,r+1,n) {
        pref[i] = pref[i-1] + (ch[i] == '(' ? 1 : -1);
        if (pref[i] < 0) return false;
    } 

    return true;
}

signed main() {
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    cin >> T;
    while (T--) {
        cin >> n >> ch + 1; n <<= 1; 
        bool completed = true; mpos = 1; pref[n+1] = -1e9;

        rep(i,1,n) {
            pref[i] = pref[i-1] + (ch[i] == '(' ? 1 : -1);
            if (pref[mpos] < pref[i]) mpos = i;
            if (pref[i] < 0) completed = false;
        } 
        if (completed) { cout << 0 << '\n'; continue; };

        int lmst = 1, rmst = n;
        while (lmst <= n and pref[lmst] >= 0) lmst ++;
        while (rmst > 0 and pref[rmst] >= 0) rmst --;

        int lck = n+2, rck = n+1;
        rep(i,1,lmst) if (pref[lck-1] < pref[i-1]) lck = i;
        rep(i,rmst+1,n) if (pref[rck] < pref[i]) rck = i;

        if (check(lck, rck)) {
            cout << 1 << '\n';
            cout << lck << ' ' << rck << '\n';
        }
        else {
            cout << 2 << '\n';
            cout << 1 << ' ' << mpos << '\n';
            cout << mpos+1 << ' ' << n << '\n';
        } 
    }
}